package com.qyx.pmpucat.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import com.mybatisflex.core.paginate.Page;
import com.mybatisflex.core.query.QueryWrapper;
import com.qyx.pmpucat.common.exception.ClientException;
import com.qyx.pmpucat.dto.QuestionnaireDTO;
import com.qyx.pmpucat.dto.QuestionnaireListResponseDTO;
import com.qyx.pmpucat.dto.QuestionnaireQueryDTO;
import com.qyx.pmpucat.entity.Questionnaire;
import com.qyx.pmpucat.entity.base.Options;
import com.qyx.pmpucat.mapper.QuestionMapper;
import com.qyx.pmpucat.mapper.QuestionnaireMapper;
import com.qyx.pmpucat.service.QuestionnaireService;
import com.qyx.pmpucat.service.UserService;
import lombok.RequiredArgsConstructor;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.List;

import static com.qyx.pmpucat.entity.table.QuestionTableDef.QUESTION;
import static com.qyx.pmpucat.entity.table.QuestionnaireTableDef.QUESTIONNAIRE;

/**
 * 问卷服务实现
 */
@Service
@RequiredArgsConstructor
public class QuestionnaireServiceImpl implements QuestionnaireService {

    private final QuestionnaireMapper questionnaireMapper;
    private final QuestionMapper questionMapper;
    private final UserService userService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Long createQuestionnaire(QuestionnaireDTO questionnaireDTO) {
        // 创建问卷
        Questionnaire questionnaire = new Questionnaire();
        BeanUtils.copyProperties(questionnaireDTO, questionnaire);
        // 设置问卷状态为未发布
        questionnaire.setStatus(0);
        // 设置创建人信息
        Long userId = StpUtil.getLoginIdAsLong();
        questionnaire.setCreateBy(userId);
        questionnaire.setCreateUser(userService.getById(userId).getUsername());

        // 保存问卷
        questionnaireMapper.insert(questionnaire);

        return questionnaire.getId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void updateQuestionnaire(QuestionnaireDTO questionnaireDTO) {
        // 检查问卷是否存在
        Long questionnaireId = questionnaireDTO.getId();
        if (questionnaireId == null) {
            throw new ClientException("问卷ID不能为空");
        }

        Questionnaire existQuestionnaire = questionnaireMapper.selectOneById(questionnaireId);
        if (existQuestionnaire == null) {
            throw new ClientException("问卷不存在");
        }

        // 已发布的问卷不能修改
        if (existQuestionnaire.getStatus() == 1) {
            throw new ClientException("已发布的问卷不能修改");
        }

        // 更新问卷信息
        Questionnaire questionnaire = new Questionnaire();
        BeanUtils.copyProperties(questionnaireDTO, questionnaire);
        questionnaireMapper.update(questionnaire);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void deleteQuestionnaire(Long id) {
        // 检查问卷是否存在
        Questionnaire existQuestionnaire = questionnaireMapper.selectOneById(id);
        if (existQuestionnaire == null) {
            throw new ClientException("问卷不存在");
        }

        // 已发布的问卷不能删除
        if (existQuestionnaire.getStatus() == 1) {
            throw new ClientException("已发布的问卷不能删除");
        }

        // 查询问卷下的所有问题
        QueryWrapper questionWrapper = QueryWrapper.create();
        questionWrapper.where(QUESTION.QUESTIONNAIRE_ID.eq(id));

        // 删除问题（选项会作为问题的一部分一起删除）
        questionMapper.deleteByQuery(questionWrapper);

        // 删除问卷
        questionnaireMapper.deleteById(id);
    }

    @Override
    public Questionnaire getQuestionnaireDetail(Long id) {
        // 检查问卷是否存在
        Questionnaire questionnaire = questionnaireMapper.selectOneWithRelationsById(id);
        if (questionnaire == null) {
            throw new ClientException("问卷不存在");
        }

        return questionnaire;
    }

    @Override
    public Page<QuestionnaireListResponseDTO> getQuestionnairePage(QuestionnaireQueryDTO queryDTO) {
        // 构建查询条件
        QueryWrapper queryWrapper = QueryWrapper.create();

        // 标题模糊查询
        if (StringUtils.hasText(queryDTO.getTitle())) {
            queryWrapper.and(QUESTIONNAIRE.TITLE.like("%" + queryDTO.getTitle() + "%"));
        }

        // 状态查询
        if (queryDTO.getStatus() != null) {
            queryWrapper.and(QUESTIONNAIRE.STATUS.eq(queryDTO.getStatus()));
        }

        // 查询问卷列表
        Page<Questionnaire> questionnairePage = questionnaireMapper.paginate(
                queryDTO.getPageNum(), queryDTO.getPageSize(), queryWrapper);

        // 转换为DTO
        List<QuestionnaireListResponseDTO> dtoList = new ArrayList<>();
        for (Questionnaire questionnaire : questionnairePage.getRecords()) {
            QuestionnaireListResponseDTO dto = new QuestionnaireListResponseDTO();
            BeanUtils.copyProperties(questionnaire, dto);

            // 查询问题数量
            QueryWrapper questionWrapper = QueryWrapper.create();
            questionWrapper.where(QUESTION.QUESTIONNAIRE_ID.eq(questionnaire.getId()));
            long questionCount = questionMapper.selectCountByQuery(questionWrapper);
            dto.setQuestionCount((int) questionCount);

            dtoList.add(dto);
        }

        // 构建分页结果
        Page<QuestionnaireListResponseDTO> result = new Page<>();
        result.setPageSize(questionnairePage.getPageSize());
        result.setPageNumber(questionnairePage.getPageNumber());
        result.setTotalPage(questionnairePage.getTotalPage());
        result.setTotalRow(questionnairePage.getTotalRow());
        result.setRecords(dtoList);

        return result;
    }

    /**
     * 下拉所有问卷
     */
    @Override
    public List<Options> dropQuestionnaire() {
        return questionMapper.selectAll().stream().map(i -> Options.builder().label(i.getTitle()).value(String.valueOf(i.getId())).build())
                .toList();
    }

} 